import { MongodbClient } from "../lib/db.client.mongodb";
import { PgClient } from "../lib/db.client.pg";

import {
  Book,
  Contact,
  ENUM_APP,
  ENUM_BOOK_DIRECTION,
  ENUM_MEDIA,
  ENUM_TON_ORDER,
  Journal,
  Media,
  MediaGroup,
  Paster,
  RefTonOrderMedia,
  RefTonOrderStamp,
  TonOrder,
  TonOrderGroup,
  User,
} from "qqlx-core";
import {
  getConditionMatchStrOrs,
  getConditionMatchStr,
  TonOrderSchema,
  TonOrderGroupSchema,
  getConditionMatchEnum,
  toDivideSafe,
  RefTonOrderStampSchema,
  PasterSchema,
  BookSchema,
  getTonOrderBookType,
  doRegularZhSort,
  MediaSchema,
  MediaGroupSchema,
  RefTonOrderMediaSchema,
  JournalSchema,
  getBookTypeTrans,
} from "qqlx-cdk";

import { Clue, User as OldUser } from "../../../qqlx.old/qqlx-core";
import { Corp as OldCorp } from "../../../qqlx.old/qqlx-core";
import { Contact as OldContact } from "../../../qqlx.old/qqlx-core";
import { Order as OldOrder, ENUM_ORDER } from "../../../qqlx.old/qqlx-core";

import { getTradeId, getUUid32 } from "../lib/crypto";
import { TonOrderGroupDao, TonOrderDao, RefTonOrderStampDao, RefTonOrderMediaDao } from "../dao/river";
import { doBashPrint } from "../lib/log";
import { ObjectId } from "mongodb";
import { JournalDao, MediaDao, MediaGroupDao, PasterDao } from "../dao/pond";
import { BookDao } from "../dao/pond";

export async function doTonOrderSaleInsert(
  mongo_master_corp_id: OldCorp["_id"],
  _id_to_user_map: Map<OldUser["_id"], User>,
  _id_to_contact_map: Map<OldContact["_id"], Contact>,
) {
  const mongodbClient = new MongodbClient("mongodb://localhost:27017/qqlx");
  const pgClient = new PgClient("127.0.0.1", "5432", "production", "postgres", "postgres");

  console.group("\n开始迁移mongo销售订单数据");
  const stat = { before: 0, wanner: 0, now: 0 };

  const master_to_order_group_map = new Map<User["uuid32"], TonOrderGroup>();
  const _id_to_sale_order_map = new Map<OldOrder["_id"], TonOrder>();
  const pg_uuid32_sale_order_map = new Map<TonOrder["uuid32"], TonOrder>();

  try {
    await mongodbClient.start();

    const colCorps = mongodbClient.getCollection("corps");
    const corp = (await colCorps.findOne<OldCorp>({ _id: mongo_master_corp_id as unknown as ObjectId })) as OldCorp;
    const corpQuery = { corpId: corp._id as unknown as ObjectId };

    const colOrders = mongodbClient.getCollection("orders");
    const saleQuery = { ...corpQuery, type: ENUM_ORDER.SALES };
    const mongo_order_list = await colOrders.find<OldOrder>(saleQuery).toArray();

    const colClues = mongodbClient.getCollection("clues");
    const mongo_clue_list = await colClues.find<Clue>({ ...corpQuery, content: new RegExp(`打印了销售单`) }).toArray();
    const mongo_order_id_clue_count_map = new Map<string, number[]>();
    for (const clue of mongo_clue_list) {
      const code = /\bXS-\d+-\d+\b/.exec(clue.content)?.[0];
      if (code) {
        if (!mongo_order_id_clue_count_map.has(code)) {
          mongo_order_id_clue_count_map.set(code, []);
        }

        // 统计订单ID对应的打印次数
        mongo_order_id_clue_count_map.set(code, [...mongo_order_id_clue_count_map.get(code)!, clue.timeCreate]);
      }
    }

    console.log("旧数据（销售订单）", mongo_order_list.length);
    stat.wanner = mongo_order_list.length;

    // 提取历史操作记录
    const mongo_clue_list_all = await colClues.find<Clue>({ ...corpQuery }).toArray();
    const order_code_clue_map = new Map<string, { content: string; timeCreate: number }[]>();
    for (const clue of mongo_clue_list_all) {
      const code = /\bXS-\d+-\d+\b/.exec(clue.content)?.[0];
      if (code) {
        if (!order_code_clue_map.has(code)) {
          order_code_clue_map.set(code, []);
        }
        order_code_clue_map.set(code, [...order_code_clue_map.get(code)!, { content: clue.content, timeCreate: clue.timeCreate }]);
      }
    }

    // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░░░▄▄▄▄▄▄░░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░▄█▀▀▀▀▀█▄░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░▄█░░▄▄▄░░█▄░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▄▄█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░▀▄▀▄▄▄▄▄▀▄▀░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

    const pgClientIns = await pgClient.start();
    const pasterDao = new PasterDao(pgClientIns.getRepository<Paster>(PasterSchema));
    const bookDao = new BookDao(pgClientIns.getRepository<Book>(BookSchema));
    const orderGroupDao = new TonOrderGroupDao(pgClientIns.getRepository<TonOrderGroup>(TonOrderGroupSchema));
    const orderDao = new TonOrderDao(pgClientIns.getRepository<TonOrder>(TonOrderSchema));
    const stampDao = new RefTonOrderStampDao(pgClientIns.getRepository<RefTonOrderStamp>(RefTonOrderStampSchema));
    const journalDao = new JournalDao(pgClientIns.getRepository<Journal>(JournalSchema));

    const mediaDao = new MediaDao(pgClientIns.getRepository<Media>(MediaSchema));
    const mediaGroupDao = new MediaGroupDao(pgClientIns.getRepository<MediaGroup>(MediaGroupSchema));
    const refTonOrderMediaDao = new RefTonOrderMediaDao(pgClientIns.getRepository<RefTonOrderMedia>(RefTonOrderMediaSchema));

    const master = _id_to_user_map.get(corp.userId) as User;
    const master_condis = [getConditionMatchStr("refOwnerUUid32", master.uuid32)];
    const master_group_condis = [...master_condis, getConditionMatchStr("name", "销售订单集合")];

    // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░░░▄▄▄▄▄▄░░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░▄█▀▀▀▀▀█▄░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░▄█░░▄▄▄░░█▄░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▄▄█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░▀▄▀▄▄▄▄▄▀▄▀░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 缓存唯一的订单数据包

    const _count = await orderGroupDao.count(master_group_condis);
    if (_count === 0) {
      const schema = getDefaultGroup(master.uuid32);
      schema.name = "销售订单集合";
      schema.sequence = 2;
      const created = await orderGroupDao.insertOne(schema);
      master_to_order_group_map.set(`${master.uuid32}:sale`, created);
    } else {
      const { firstMatch } = await orderGroupDao.queryMatch(master_group_condis);
      if (!firstMatch) throw { message: `数据包异常：${master.nickname}` };
      master_to_order_group_map.set(`${master.uuid32}:sale`, firstMatch);
    }

    // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░░░▄▄▄▄▄▄░░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░▄█▀▀▀▀▀█▄░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░▄█░░▄▄▄░░█▄░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▄▄█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░▀▄▀▄▄▄▄▄▀▄▀░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 迁移销售订单

    const pasterLs = await pasterDao.queryAll(master_condis);
    const pg_order_sale_condis = [...master_condis, getConditionMatchEnum("type", ENUM_TON_ORDER.SALE)];
    const pg_order_sale_count = await orderDao.count(pg_order_sale_condis);
    stat.before = pg_order_sale_count;

    //
    if (pg_order_sale_count === 0) {
      const only_sale_group = master_to_order_group_map.get(`${master.uuid32}:sale`) as TonOrderGroup;
      const tonOrderSchemaLs = mongo_order_list.map((mongo_order) => {
        const pg_order_schema = getDefaultOrder(mongo_order, master.uuid32, pasterLs.list);

        // 交易7要素
        pg_order_schema.tradeId = getTradeId();
        pg_order_schema.tradeTime = mongo_order.timeContract.toString();
        pg_order_schema.tradeYear = new Date(mongo_order.timeContract).getFullYear();
        pg_order_schema.tradeMonth = new Date(mongo_order.timeContract).getMonth() + 1;
        pg_order_schema.tradeScope = `${master.uuid32}-${only_sale_group.id}`;
        //
        const creatorCache = _id_to_user_map.get(mongo_order.creatorId) as User;
        if (!creatorCache) throw { message: `创建人异常：${mongo_order.creatorId}` };
        pg_order_schema.refCreatorId = creatorCache.uuid32;

        const contactCache = _id_to_contact_map.get(mongo_order.contactId) || _id_to_contact_map.get(`${master.uuid32}:contact:unknown`);
        if (contactCache?.refOwnerUUid32 !== master.uuid32) throw { message: `联系人异常：${mongo_order.contactId}` };
        pg_order_schema.refContactId = contactCache.id;

        //
        pg_order_schema.refTonOrderGroupId = only_sale_group.id;
        pg_order_schema.contractSideOp = contactCache.name;
        pg_order_schema.contractBrief = getBrief();
        pg_order_schema.contractTime = mongo_order.timeContract.toString();
        return pg_order_schema;
      });

      // 批量插入订单
      const batchCount = 2000;
      const saleOrderCreatedLs: TonOrder[] = [];
      while (tonOrderSchemaLs.length > 0) {
        const part = tonOrderSchemaLs.splice(0, batchCount);
        const ls = await orderDao.insertManyAndQuery(part);
        saleOrderCreatedLs.push(...ls);
        doBashPrint(`第（1/3）步正在推送订单（${batchCount}）剩余${tonOrderSchemaLs.length}`);
      }

      // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░░░▄▄▄▄▄▄░░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░▄█▀▀▀▀▀█▄░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░▄█░░▄▄▄░░█▄░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▄▄█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░▀▄▀▄▄▄▄▄▀▄▀░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 迁移订单印章

      const stampLs: RefTonOrderStamp[] = [];
      saleOrderCreatedLs.map((d) => {
        if (d.name) {
          const managerCache = _id_to_user_map.get(d.name);
          if (d.name && !managerCache) throw { message: `复核异常：${d.name}` };
          stampLs.push(getDefaultStamp(d.uuid32, master.uuid32, "销售订单签字", "已经发货"));
        }

        if (d.desc) {
          const accountorCache = _id_to_user_map.get(d.desc);
          if (d.desc && !accountorCache) throw { message: `结清异常：${d.desc}` };
          stampLs.push(getDefaultStamp(d.uuid32, master.uuid32, "销售订单签字", "财务已结清"));
        }
      });
      while (stampLs.length > 0) {
        const part = stampLs.splice(0, batchCount);
        await stampDao.insertMany(part);
        doBashPrint(`第（2/3）步正在推送印章（${batchCount}）剩余${stampLs.length}`);
      }

      // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░░░▄▄▄▄▄▄░░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░▄█▀▀▀▀▀█▄░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░▄█░░▄▄▄░░█▄░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▄▄█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░▀▄▀▄▄▄▄▄▀▄▀░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 迁移订单打印数据

      const _media_group_count = await mediaGroupDao.count(master_group_condis);
      const only_media_group = {} as { value: MediaGroup };
      if (_media_group_count === 0) {
        const schema = getDefaultMediaGroup(master.uuid32);
        schema.name = "销售订单集合";
        schema.sequence = 2;
        only_media_group.value = await mediaGroupDao.insertOne(schema);
      } else {
        const { firstMatch } = await mediaGroupDao.queryMatch(master_group_condis);
        if (!firstMatch) throw { message: `数据包异常：${master.nickname}` };
        only_media_group.value = firstMatch;
      }

      const media_schema_ls: Media[] = [];
      const journal_schema_ls: Journal[] = [];
      const order_code_map = new Map<string, TonOrder>();
      for (const order of saleOrderCreatedLs) {
        // 1
        order_code_map.set(order.code, order);

        // 2 恢复订单打印/历史记录
        const counts = mongo_order_id_clue_count_map.get(order.code) || [];
        if (counts.length > 0) {
          for (const time of counts) {
            const media_schema = getDefaultMedia(master.uuid32);
            media_schema.refMediaGroupId = only_media_group.value.id;
            media_schema.refCreatorId = order.refCreatorId;
            media_schema.content = order.code;
            media_schema.timeCreate = time.toString();
            media_schema.timeUpdate = time.toString();
            media_schema_ls.push(media_schema);
          }
        }

        // 3 恢复历史记录
        const clues = order_code_clue_map.get(order.code) || [];
        if (clues.length > 0) {
          for (const { content, timeCreate } of clues) {
            const journal_schema = new JournalSchema();
            journal_schema.tradeId = order.tradeId;
            journal_schema.tradeTime = order.tradeTime;
            journal_schema.tradeYear = order.tradeYear;
            journal_schema.tradeMonth = order.tradeMonth;
            journal_schema.tradeScope = order.tradeScope;
            journal_schema.refCreatorId = order.refCreatorId;
            journal_schema.refContactId = order.refContactId;

            journal_schema.refOwnerUUid32 = master.uuid32;
            journal_schema.content = content;
            journal_schema.app = ENUM_APP.RIVER_TON;
            journal_schema.timeCreate = timeCreate.toString();
            journal_schema.timeUpdate = timeCreate.toString();
            journal_schema_ls.push(journal_schema);
          }
        }
      }

      const media_created_ls: Media[] = [];
      while (media_schema_ls.length > 0) {
        const part = media_schema_ls.splice(0, batchCount);
        const ls = await mediaDao.insertManyAndQuery(part);
        media_created_ls.push(...ls);
        doBashPrint(`第（2.5/3）步正在推送媒体（${batchCount}）剩余${media_schema_ls.length}`);
      }

      const ref_ton_order_media_ls: RefTonOrderMedia[] = media_created_ls.map((media) => ({
        ...new RefTonOrderMediaSchema(),
        refOwnerUUid32: master.uuid32,
        refTonOrderId: order_code_map.get(media.content)?.uuid32 || "",
        refMediaId: media.id,
        timeCreate: media.timeCreate,
        timeUpdate: media.timeUpdate,
      }));

      while (ref_ton_order_media_ls.length > 0) {
        const part = ref_ton_order_media_ls.splice(0, batchCount);
        await refTonOrderMediaDao.insertMany(part);
        doBashPrint(`第（2.75/3）步正在推送订单/媒体/历史记录（${batchCount}）剩余${ref_ton_order_media_ls.length}`);
      }

      while (journal_schema_ls.length > 0) {
        const part = journal_schema_ls.splice(0, batchCount);
        await journalDao.insertMany(part);
        doBashPrint(`第（2.9/3）步正在推送历史记录（${batchCount}）剩余${journal_schema_ls.length}`);
      }

      // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░░░▄▄▄▄▄▄░░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░▄█▀▀▀▀▀█▄░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░▄█░░▄▄▄░░█▄░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░█░░█▄▄█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░▀▄▀▄▄▄▄▄▀▄▀░░░░░░░░░░░░░░░░░░░░░░░░░░
      // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 订单记账

      const bookSchemaLs: Book[] = [];
      saleOrderCreatedLs
        .filter((o) => o.isDisabled === false)
        .map((order) => {
          const base = new BookSchema();

          // 交易7要素
          base.tradeId = order.tradeId;
          base.tradeTime = order.tradeTime;
          base.tradeYear = order.tradeYear;
          base.tradeMonth = order.tradeMonth;
          base.tradeScope = order.tradeScope;
          base.refCreatorId = order.refCreatorId;
          base.refContactId = order.refContactId;

          //
          base.refOwnerUUid32 = master.uuid32;
          base.coupleId = getUUid32();
          base.amount = toDivideSafe(order.amount, 100, 2);

          const { typeJIE, typeDAI } = getTonOrderBookType(order.type);
          const Jie = structuredClone(base);
          Jie.type = typeJIE;
          Jie.direction = ENUM_BOOK_DIRECTION.JIE;
          Jie.remark = getBookTypeTrans(typeJIE)?.zh || "";
          bookSchemaLs.push(Jie);

          const Dai = structuredClone(base);
          Dai.type = typeDAI;
          Dai.direction = ENUM_BOOK_DIRECTION.DAI;
          Dai.remark = getBookTypeTrans(typeDAI)?.zh || "";
          bookSchemaLs.push(Dai);
        });
      while (bookSchemaLs.length > 0) {
        const part = bookSchemaLs.splice(0, batchCount);
        await bookDao.insertMany(part);
        doBashPrint(`第（3/3）步为销售单登记明细账（${batchCount}）剩余${bookSchemaLs.length}`);
      }
    }

    // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░░░▄▄▄▄▄▄░░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░▄█▀▀▀▀▀█▄░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░▄█░░▄▄▄░░█▄░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▀▀█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░█░░█▄▄█░░█░░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░▀▄▀▄▄▄▄▄▀▄▀░░░░░░░░░░░░░░░░░░░░░░░░░░
    // ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 缓存数据

    const oids = mongo_order_list.map((c) => c._id);
    const condis3 = [...pg_order_sale_condis, getConditionMatchStrOrs("content", oids)];
    const orderAll = await orderDao.queryAll(condis3);
    orderAll.list.map((exist) => {
      _id_to_sale_order_map.set(exist.content, exist);
      pg_uuid32_sale_order_map.set(exist.uuid32, exist);
    });

    const pgCountFinal = await orderDao.count(pg_order_sale_condis);
    stat.now = pgCountFinal;

    console.log(`🔴迁移前 >> 迁移后 / river_ton_order`, stat.before, stat.now);
    console.log(`期望`, stat.wanner);
    console.log(`📉误差`, stat.now - stat.before - stat.wanner);
    console.groupEnd();
    console.log("====================================");
  } finally {
    await pgClient.stop();
    await mongodbClient.stop();
  }

  return { master_to_order_group_map, _id_to_sale_order_map, pg_uuid32_sale_order_map };
}

function getDefaultGroup(userId: string) {
  const schema: TonOrderGroup = new TonOrderGroupSchema();
  schema.refOwnerUUid32 = userId;
  schema.name = "上海办公室";
  return schema;
}

function getDefaultOrder(mongo_order: OldOrder, masterId: User["uuid32"], pasterLs: Paster[]) {
  const schema: TonOrder = new TonOrderSchema();
  schema.isDisabled = mongo_order.isDisabled;
  schema.timeCreate = mongo_order.timeCreate.toString();
  schema.timeUpdate = mongo_order.timeUpdate.toString();
  schema.type = ENUM_TON_ORDER.SALE;
  schema.code = mongo_order.code;

  const value = toDivideSafe(mongo_order.amount, 100, 2);
  schema.amount = value;
  schema.amountTax = mongo_order.isNotTax ? 0 : toDivideSafe(value * 0.13, 1, 0);

  schema.refOwnerUUid32 = masterId;
  schema.name = mongo_order.managerId; // 用于存储是否/复核
  schema.desc = mongo_order.accounterId; // 用于存储是否/财务复核
  schema.content = mongo_order._id; // 用于存储历史订单id
  schema.remark = mongo_order.remark;
  schema.labelStr = doRegularZhSort(pasterLs.map((p) => p.name)).join("；");
  return schema;
}

function getDefaultStamp(orderId: TonOrder["uuid32"], masterId: User["uuid32"], stampName: string, desc: string) {
  const schema: RefTonOrderStamp = new RefTonOrderStampSchema();
  schema.refOwnerUUid32 = masterId;
  schema.refCreatorId = masterId;
  schema.refTonOrderId = orderId;

  schema.name = stampName;
  schema.desc = desc;
  return schema;
}

function getBrief() {
  let _b = "1、购货方在货物发货/收货时，应当面点清数量并签收，提货人/收货人在本单上签字后，购货方即对本单上所载内容认可。";
  _b +=
    "2、按产品质量法规定，购货方在使用供方货品前，必须委托权威机构进行检测，确认其品质符合质量要求，方可投入使用。未经检测投入使用，造成一切后果由购货方自负。";
  _b += "3、如经检验有质量问题，必须在七天内提出。本公司可予以退换货（拆包或损坏不予退换），并承担一定的损失（以提货单注明金额为准）。";
  _b += "4、本销售单等同于合同，并代替送货单使用，提货人/收货人签名后生效，如有纠纷在供货方所在地解决。";
  return _b;
}

function getDefaultMediaGroup(userId: User["uuid32"]) {
  const schema: MediaGroup = new MediaGroupSchema();
  schema.refOwnerUUid32 = userId;
  schema.name = "默认媒体集合";
  return schema;
}

function getDefaultMedia(userId: User["uuid32"]) {
  const schema: Media = new MediaSchema();
  schema.refOwnerUUid32 = userId;
  schema.type = ENUM_MEDIA.NONE;
  return schema;
}
